Ja, also wo sind wir angekommen? Letzte Woche. Wir haben uns ja schon mit den Hazards beschäftigt,

beziehungsweise ich fasse nochmal ganz kurz zusammen. Also wir hatten die Sache mit dem,

wieso geht denn das heute nicht? Also seltsam, warum das heute nicht geht. Also wenn noch jemand

kommt, dann sehen Sie es ja. So, also wo sind wir angekommen? Wir haben uns ja mit diesen CISC

Architekturen, also in Mikroprogrammierung habe ich ihn nochmal als Wiederholung von der GRA

nochmal erzählt und von CISC kam eben dann dieser Übergang zu RISC, eben weil die ganze

Sache nicht mehr effizient genug war, beziehungsweise es war so, dass die Compilerbauer ein Großteil der

Befehle nicht mehr verwendet haben, die ihnen eigentlich die CISC Architekten angeboten haben.

Gut, dann sind wir zu RISC übergegangen. Ein wesentlicher Wesenszug vom RISC ist das Pipelining,

dass wir also die einzelnen Befehle innerhalb von Befehls Phasen zeitlich überlappt ausführen und

dazu haben wir uns die optimalen Speedup ausgerechnet und der ist K. Wenn wir K-Stufen haben,

K-Pipelangstufen, dann können wir einen optimalen Speedup von K erzielen. Okay,

allerdings ist es nicht sinnvoll, die K so groß wie möglich zu machen, denn das würde die Hardwarekosten

nur unnötig vergrößern und wir hätten auch das Problem, dass wir viele leere Pipelinezyklen bei

Verzweigungen hätten und zwar zu den Verzweigungen kommen wir nämlich jetzt gleich. So, okay,

dann das haben wir glaube ich auch schon gemacht, ich glaube wir sind bis vor die 29 gekommen. Und

was sind Superskaladeeinheiten? Superskaladeeinheiten ist, dass man eben nicht nur,

heute irgendwie funktioniert der Mechanismus nicht, mach nichts. Ich will das zumachen,

wenn der Steffen nebenan sitzt, dann hört ja meine Freundin sie noch mit. So Superskaladeeinheiten,

dass man nicht nur eine Pipeline, sondern gleich mehrere Pipeline-Stufen parallel ausnutzen. Okay,

ich habe mir nur dieses Bildchen hier gerade gezeigt, mehrere von diesen Eierköpfen holen

sich da jetzt die Befehle eben ab, der gibt einen Takt vor und die rennen alle kunderbunt durch die

Gegend und führen jeweils die Aufgabe des Befehlszyklus aus, der für sie gedacht ist. Also der

hat zum Beispiel einen Taschenrechner, der ist wahrscheinlich die Ausführungseinheit. Okay,

das war Superskalader, Rechner, genau. Das allgemeine Prinzip, fassen wir das auch noch mal zusammen,

es ist keine direkte Parallelität, wie jetzt beispielsweise bei einem Multicore, wo direkt

von der Software, beispielsweise bei Maltes Retting, bei OpenMP Hinweise gegeben werden müssen,

sodass der Compiler Code erzeugt, der dann auf zwei Kern auch läuft, sondern es ist eine implizite

Parallelität, das heißt das Herausziehen von Parallelität aus dem sequenziellen Befehlsstrom,

was komplett in der Hardware passiert. Das ist das Wesentliche und was spricht jetzt auch noch

dagegen, dass man endlich oder sehr große Pipeline-Stufen machen, eben diese zum Beispiel

Datenabhängigkeiten, die sogenannten Datenhesserts, da habe ich Ihnen dieses Beispiel hier gezeigt.

Also beispielsweise, ich will jetzt R1 mit R2 multiplizieren und das Ergebnis soll nach R3

geschrieben werden. Dann schauen wir das jetzt hier an, erste Phase Befehl holen, zweite Phase

dekodieren, dritte Phase Operanten holen, vierte Phase Befehl ausführen und der zweite Befehl ist

auch schon in der Pipeline, der erholt seine Operanten, genau in dem Moment, wo der erste

Befehl noch ausgeführt wird. Das heißt, das R3 ist noch nicht zurückgeschrieben. Was passiert?

Der hier, der Befehl wird ein anderes, wird ein falsches R3 lesen. Und wie wir das jetzt auflösen,

diese Fehlerquelle beseitigen können, das schauen wir uns heute noch nicht, aber in der nächsten

Woche an. Was wir uns heute anschauen, sind wie wir solche Steuerungshesserts, wie wir

dem begegnen können. Also beispielsweise, hier werden jetzt eine Abfrage R1 gleich R2,

dann sollen wir zu 72 springen. Jetzt sind aber auch schon die Folgebefehle an der Adresse 44,

48 und 52 in der Pipeline. Und was passiert? Ja, wenn wir den Befehl ausführen, den bedingten

Sprungbefehl Befehl ausführen, heißt jetzt, wir werten die Bedingungen aus. Wir gucken nach,

ob R1 gleich R2 ist. Und jetzt erst in dem Moment, zum diskreten Zeitstück 4, wissen wir,

ob R1 gleich R2 ist. Jetzt wenn R1 leider gleich R2 ist, müssten wir mit 72 weitermachen. Aber

leider ist der nächste Befehl, die nächsten drei Befehle, die schon in der Pipeline sind,

sind verkehrt. Wir sind nämlich 44, 48 und 52. Wir müssten aber an 72 fortsetzen. Also das ist

dann ein sogenannter Controlhessert oder Steuerungshessert. Und Hesserts beim Pipeline

können also, das sind die drei Klassen von Hesserts, die entstehen, entstehen können,